package com.kk.transactional.service;

import cn.hutool.core.thread.ThreadUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.benmanes.caffeine.cache.Cache;
import com.kk.transactional.entity.Order;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

@Slf4j
@Service
public class MultiLevelCacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 本地缓存（Caffeine）
    @Autowired
    private Cache<String, Object> localCache;

    // 延迟双删线程池
    @Autowired
    private Executor cacheThreadPool;

    @Autowired
    private IOrderService orderService;

    /**
     * 获取缓存数据（多级缓存）
     * 1. 先查本地缓存
     * 2. 本地缓存没有则查Redis
     * 3. Redis没有则查数据库
     */
    public <T> T get(String key, Class<T> clazz) {
        // 1. 查本地缓存
        Object value = null;
        try {
            value = localCache.getIfPresent(key);
            log.info("local cache: {}-{}", key, value);
        } catch (Exception e) {
            log.warn("local cache get {} is null", key);
        }
        if (value != null) {
            log.debug("Get from local cache: {}", key);
            return clazz.cast(value);
        }

        // 2. 查Redis缓存
        value = redisTemplate.opsForValue().get(key);
        log.info("redis cache: {}-{}", key, value);
        if (value != null) {
            log.debug("Get from redis cache: {}", key);
            // 回填本地缓存
            localCache.put(key, value);
            return clazz.cast(value);
        }

        // 3. 查数据库
        Order order = new Order();
        order.setGoods(key);
        Order orderServiceOne = orderService.getOne(new QueryWrapper<>(order));
        log.debug("Cache miss, query from DB: {}", key);
        // 更新redis缓存
        // 更新本地缓存
        setCache(key, orderServiceOne);

        return (T) orderServiceOne;
    }

    /**
     * 更新缓存数据（延迟双删策略）
     * 1. 先删除Redis缓存
     * 2. 更新数据库
     * 3. 延迟一定时间后再次删除Redis和本地缓存
     */
    public void update(String key, Object value) {
        // 1. 先删除Redis缓存、本地缓存
        deleteCache(key);
        log.debug("First delete redis and local cache: {}", key);

        // 2. 更新数据库（这里需要业务代码实现）
        log.debug("Update database: {}", key);
        Order order = new Order();
        order.setGoods(key);
        order.setPersonId((new Random().nextInt(100)));
        orderService.saveOrUpdate(order);

        // 3. 延迟双删
        cacheThreadPool.execute(() -> {
            // 延迟n s删除，由业务决定
            ThreadUtil.sleep(1000);
            // 删除Redis缓存
            // 删除本地缓存
            deleteCache(key);
            log.debug("Delete local cache: {}", key);
        });
    }

    /**
     * 设置缓存（同时设置本地和Redis缓存）
     */
    public void setCache(String key, Object value) {
        if (StringUtils.isEmpty(key) || value == null) {
            return;
        }

        // 设置Redis缓存
        redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);

        // 设置本地缓存
        localCache.put(key, value);
    }

    /**
     * 删除缓存（同时删除本地和Redis缓存）
     */
    public void deleteCache(String key) {
        // 删除Redis缓存
        redisTemplate.delete(key);

        // 删除本地缓存
        try {
            localCache.invalidate(key);
        } catch (Exception e) {
            log.warn("MSG={}",e.getMessage());
        }
    }
}